All files / src/ucc-bridge ucc-connector.ts

80.3% Statements 53/66
66.67% Branches 2/3
71.43% Functions 15/21
79.31% Lines 46/58

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 1091x 1x 1x     1x 1x             1x 5x       5x 5x     5x 5x     5x 4x 4x 4x 4x               1x 5x               1x 5x   4x       4x 4x 4x     5x 5x 5x 5x   5x         5x 5x 5x 5x 5x   5x 4x   5x           5x         5x           5x 5x     5x   5x   5x 5x   5x    
import net from "net"
import createJsonParser from "stream-json"
import Assembler, { connectTo as createJsonAssembler } from "stream-json/Assembler"
import { UccBridgeEvent } from "./neon-connector"
import { IpcMainEvent } from "electron"
import { Readable } from "stream"
import { chain } from "stream-chain"
 
export interface UccClient {
  isConnected: boolean
  sendEvent(event: IpcMainEvent, eventId: string, data: UccBridgeEvent): void
}
 
export const createTcpJsonStreamAssembler = (readableStream: Readable): Assembler => {
  const pipeline = chain([
    readableStream,
    createJsonParser({ jsonStreaming: true }),
  ])
  pipeline.on("end", () => console.log("Stream ended"))
  pipeline.on("error", error => {
    console.log("Json event can't parsed error: ", error)
  })
  const asm = createJsonAssembler(pipeline)
  return asm
}
 
export const handleEventResponse = (eventReplyHandler: Record<string, IpcMainEvent>) => (asm: Assembler): void => {
  try {
    const jsonResponse = asm.current
    Eif (eventReplyHandler.hasOwnProperty(jsonResponse.eventId)) {
      eventReplyHandler[jsonResponse.eventId].reply("event-response", jsonResponse)
    } else {
      console.log("Received new event from ucc-client: ", jsonResponse)
    }
  } catch (err) {
    console.log("Can't parse ucc client result: ", err)
  }
}
const unconnectedUccClientSendEvent =  () =>
  (event: IpcMainEvent, eventId: string, _: UccBridgeEvent) => {
    event.reply("event-response", {
      eventId: eventId,
      error: "Unknown error"
    })
  }
 
const uccClientSendEvent =
  (uuId: string, eventReplyHandler: Record<string, Electron.IpcMainEvent>, socketClient: net.Socket) =>
    (event: IpcMainEvent, eventId: string, data: UccBridgeEvent) => {
 
      const header = {
        neonIpcSession: uuId,
        eventId: eventId
      }
      eventReplyHandler[eventId] = event
      const newEvent = { ...header, ...data }
      socketClient.write(JSON.stringify(newEvent) + "\n\r")
    }
 
const createTcpConnection = async (port: number, readableStream: Readable, uuId: string, eventReplyHandler: Record<string, Electron.IpcMainEvent>) => {
  return new Promise<UccClient>((resolve, _) => {
    const socketClient = net.connect({ host: "localhost", port: port }, () => {
      socketClient.setEncoding("utf8")
    })
    const uccClient = {
      sendEvent: unconnectedUccClientSendEvent(),
      isConnected: false
    } as UccClient
 
    socketClient.on("connect", () => {
      console.log("Connected to the UCC-Client.")
      uccClient.sendEvent = uccClientSendEvent(uuId, eventReplyHandler, socketClient)
      uccClient.isConnected = true
      resolve(uccClient)
    })
    socketClient.on("data", (data: string) => {
      readableStream.push(data)
    })
    socketClient.on("error", (data: string) => {
      uccClient.sendEvent = unconnectedUccClientSendEvent()
      uccClient.isConnected = false
      resolve(uccClient)
      console.log("UCC-Client error", data)
    })
    socketClient.on("end", () => {
      console.log("disconnected from the UCC-Client.")
      uccClient.sendEvent = unconnectedUccClientSendEvent()
      uccClient.isConnected = false
    })
    socketClient.on("close", () => {
      console.log("close socket")
    })
  })
}
 
export const setupUccConnection = async (uuId: string, port: number): Promise<UccClient> => {
  const eventReplyHandler = {} as Record<string, IpcMainEvent>
 
  // NodeJs stream initialize format...
  const readableStream: Readable = new Readable()
  /* eslint-disable @typescript-eslint/no-empty-function */
  readableStream._read = () => {
  }
  const assembler = createTcpJsonStreamAssembler(readableStream)
  assembler.on("done", handleEventResponse(eventReplyHandler))
 
  return await createTcpConnection(port, readableStream, uuId, eventReplyHandler)
}